package _case

import "fmt"

// 不通过类型相同的逻辑
// 如果传入的是指针类型，就需要使用iterfase扩起来，避免识别成 T *int

func SimpleCase() {
	var a, b = 4, 6
	var c, d float64 = 7.2, 7.9
	fmt.Println("使用泛型", getMaxNum[int](a, b)) //指定传的值类型
	fmt.Println("使用泛型", getMaxNum[float64](c, d))
}

func getMaxNum[K CusNumT](a, b K) K { // T调用时需要被告知，
	if a > b {
		return a
	}
	return b
}

// 自定义一个类型
type CusNumT interface {
	//Get() string //之前接口用于一个方法集
	//Set(s string)
	//支持以下类型,取并集
	uint8 | int | int32 | float64 | ~int64 // ~表示 包括int64以及int64所有衍生类型
	//多行的话取交集
	uint8 | int | int32 | float64 | ~int64 | uint16
	//多行之间没有交集，那就约束不了
}

// int64类型衍生类型，需要做类型转化
type Myint64 int64 // Myinst64为int64的衍生类型，是具有基础类型int64的新类型

// 别名 ：所有都一样，不需要做转化
type Myint32 = int32

func CusNumCase() {
	// 别名
	var a, b int32 = 4, 6
	var a1, b1 Myint32 = 4, 6
	fmt.Println("自定义泛型", getCuxxNum[int32](a, b)) //指定传的值类型
	fmt.Println("自定义泛型", getCuxxNum[Myint32](a1, b1))

	//自定义类型
	var a2, b2 float64 = 4, 6
	fmt.Println("自定义泛型", getCuxxNum[float64](a2, b2)) //指定传的值类型

	var a3, b3 int64 = 4, 6
	var a4, b4 Myint64 = 4, 6
	fmt.Println("自定义泛型", getCuxxNum[int64](a3, b3)) //指定传的值类型
	fmt.Println("自定义泛型", getCuxxNum[Myint64](a4, b4))

}
func getCuxxNum[K CusNumT](a, b K) K { // T调用时需要被告知，
	if a > b {
		return a
	}
	return b
}

// 内置的类型
func BuiltInCase() {
	var a, b string = "ww", "sss"
	fmt.Println("内置 compaeable 泛型类型约束", getBuiltInCase(a, b))
	var s = 1
	prinBuiltInAny(s)
}

// comparable只支持判断等于和不等于，返回的是一个bool类型
func getBuiltInCase[T comparable](a, b T) bool {
	if a == b {
		return true
	}
	return false

}

// any类型

func prinBuiltInAny[T any](a T) {
	fmt.Println("内置any类型", a)
}

// 泛型切片的定义
